home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / ZSI / generate / wsdl2python.pyo (.txt) < prev   
Python Compiled Bytecode  |  2008-10-13  |  15KB  |  414 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import os
  5. import sys
  6. import warnings
  7. from ZSI import _get_idstr
  8. from ZSI.wstools.logging import getLogger as _GetLogger
  9. from ZSI.wstools import WSDLTools
  10. from ZSI.wstools.WSDLTools import SoapAddressBinding, SoapBodyBinding, SoapBinding, MimeContentBinding, HttpUrlEncodedBinding
  11. from ZSI.wstools.XMLSchema import SchemaReader, ElementDeclaration, SchemaError
  12. from ZSI.typeinterpreter import BaseTypeInterpreter
  13. from ZSI.generate import WsdlGeneratorError, Wsdl2PythonError
  14. from containers import *
  15. from ZSI.generate import utility
  16. from ZSI.generate.utility import NamespaceAliasDict as NAD
  17. from ZSI.generate.utility import GetModuleBaseNameFromWSDL
  18.  
  19. class WriteServiceModule:
  20.     client_module_suffix = '_client'
  21.     messages_module_suffix = '_messages'
  22.     types_module_suffix = '_types'
  23.     logger = _GetLogger('WriteServiceModule')
  24.     
  25.     def __init__(self, wsdl, addressing = False, notification = False, do_extended = False, extPyClasses = None, configParser = None):
  26.         self._wsdl = wsdl
  27.         self._addressing = addressing
  28.         self._notification = notification
  29.         self._configParser = configParser
  30.         self.usedNamespaces = None
  31.         self.services = []
  32.         self.client_module_path = None
  33.         self.types_module_name = None
  34.         self.types_module_path = None
  35.         self.messages_module_path = None
  36.         self.do_extended = do_extended
  37.         self.extPyClasses = extPyClasses
  38.  
  39.     
  40.     def getClientModuleName(self):
  41.         name = GetModuleBaseNameFromWSDL(self._wsdl)
  42.         if not name:
  43.             raise WsdlGeneratorError, 'could not determine a service name'
  44.         
  45.         if self.client_module_suffix is None:
  46.             return name
  47.         
  48.         return '%s%s' % (name, self.client_module_suffix)
  49.  
  50.     
  51.     def setTypesModuleName(self, name):
  52.         self.types_module_name = name
  53.  
  54.     
  55.     def getTypesModuleName(self):
  56.         if self.types_module_name is not None:
  57.             return self.types_module_name
  58.         
  59.         name = GetModuleBaseNameFromWSDL(self._wsdl)
  60.         if not name:
  61.             raise WsdlGeneratorError, 'could not determine a service name'
  62.         
  63.         if self.types_module_suffix is None:
  64.             return name
  65.         
  66.         return '%s%s' % (name, self.types_module_suffix)
  67.  
  68.     
  69.     def setClientModulePath(self, path):
  70.         self.client_module_path = path
  71.  
  72.     
  73.     def getTypesModulePath(self):
  74.         return self.types_module_path
  75.  
  76.     
  77.     def setTypesModulePath(self, path):
  78.         self.types_module_path = path
  79.  
  80.     
  81.     def gatherNamespaces(self):
  82.         if self.usedNamespaces is not None:
  83.             return None
  84.         
  85.         self.logger.debug('gatherNamespaces')
  86.         self.usedNamespaces = { }
  87.         for schema in self._wsdl.types.values():
  88.             tns = schema.getTargetNamespace()
  89.             self.logger.debug('Register schema(%s) -- TNS(%s)' % (_get_idstr(schema), tns))
  90.             if self.usedNamespaces.has_key(tns) is False:
  91.                 self.usedNamespaces[tns] = []
  92.             
  93.             self.usedNamespaces[tns].append(schema)
  94.             NAD.add(tns)
  95.         
  96.         for k, v in SchemaReader.namespaceToSchema.items():
  97.             self.logger.debug('Register schema(%s) -- TNS(%s)' % (_get_idstr(v), k))
  98.             if self.usedNamespaces.has_key(k) is False:
  99.                 self.usedNamespaces[k] = []
  100.             
  101.             self.usedNamespaces[k].append(v)
  102.             NAD.add(k)
  103.         
  104.  
  105.     
  106.     def writeClient(self, fd, sdClass = None, **kw):
  107.         if not sdClass:
  108.             pass
  109.         sdClass = ServiceDescription
  110.         print >>fd, '#' * 50
  111.         print >>fd, '# file: %s.py' % self.getClientModuleName()
  112.         print >>fd, '# '
  113.         print >>fd, '# client stubs generated by "%s"' % self.__class__
  114.         print >>fd, '#     %s' % ' '.join(sys.argv)
  115.         print >>fd, '# '
  116.         print >>fd, '#' * 50
  117.         self.services = []
  118.         for service in self._wsdl.services:
  119.             sd = sdClass(self._addressing, do_extended = self.do_extended, wsdl = self._wsdl)
  120.             if len(self._wsdl.types) > 0:
  121.                 sd.setTypesModuleName(self.getTypesModuleName(), self.getTypesModulePath())
  122.             
  123.             self.gatherNamespaces()
  124.             sd.fromWsdl(service, **kw)
  125.             sd.write(fd)
  126.             self.services.append(sd)
  127.         
  128.  
  129.     
  130.     def writeTypes(self, fd):
  131.         print >>fd, '#' * 50
  132.         print >>fd, '# file: %s.py' % self.getTypesModuleName()
  133.         print >>fd, '#'
  134.         print >>fd, '# schema types generated by "%s"' % self.__class__
  135.         print >>fd, '#    %s' % ' '.join(sys.argv)
  136.         print >>fd, '#'
  137.         print >>fd, '#' * 50
  138.         print >>fd, TypesHeaderContainer()
  139.         self.gatherNamespaces()
  140.         for l in self.usedNamespaces.values():
  141.             sd = SchemaDescription(do_extended = self.do_extended, extPyClasses = self.extPyClasses)
  142.             for schema in l:
  143.                 sd.fromSchema(schema)
  144.             
  145.             sd.write(fd)
  146.         
  147.  
  148.  
  149.  
  150. class ServiceDescription:
  151.     separate_messages = False
  152.     logger = _GetLogger('ServiceDescription')
  153.     
  154.     def __init__(self, addressing = False, do_extended = False, wsdl = None):
  155.         self.typesModuleName = None
  156.         self.messagesModuleName = None
  157.         self.wsAddressing = addressing
  158.         self.imports = ServiceHeaderContainer()
  159.         self.messagesImports = ServiceHeaderContainer()
  160.         self.locator = ServiceLocatorContainer()
  161.         self.bindings = []
  162.         self.messages = []
  163.         self.do_extended = do_extended
  164.         self._wsdl = wsdl
  165.  
  166.     
  167.     def setTypesModuleName(self, name, modulePath = None):
  168.         self.typesModuleName = '%s' % name
  169.         if modulePath is not None:
  170.             self.typesModuleName = '%s.%s' % (modulePath, name)
  171.         
  172.  
  173.     
  174.     def fromWsdl(self, service, **kw):
  175.         self.imports.setTypesModuleName(self.typesModuleName)
  176.         self.imports.appendImport(kw.get('imports', []))
  177.         self.locator.setUp(service)
  178.         
  179.         try:
  180.             bindings = map((lambda p: p.binding), service.ports)
  181.         except:
  182.             warnings.warn('not all ports have binding declared,')
  183.             bindings = ()
  184.  
  185.         for port in service.ports:
  186.             if port.binding not in bindings:
  187.                 continue
  188.             
  189.             while port.binding in bindings:
  190.                 bindings.remove(port.binding)
  191.             desc = BindingDescription(useWSA = self.wsAddressing, do_extended = self.do_extended, wsdl = self._wsdl)
  192.             
  193.             try:
  194.                 desc.setUp(port.getBinding())
  195.             except Wsdl2PythonError:
  196.                 ex = None
  197.                 self.logger.warning('Skipping port(%s)' % port.name)
  198.                 if len(ex.args):
  199.                     self.logger.warning(ex.args[0])
  200.                     continue
  201.                 continue
  202.  
  203.             desc.setReaderClass(kw.get('readerclass'))
  204.             desc.setWriterClass(kw.get('writerclass'))
  205.             for soc in desc.operations:
  206.                 if soc.hasInput() is True:
  207.                     mw = MessageWriter(do_extended = self.do_extended)
  208.                     mw.setUp(soc, port, input = True)
  209.                     self.messages.append(mw)
  210.                     if soc.hasOutput() is True:
  211.                         mw = MessageWriter(do_extended = self.do_extended)
  212.                         mw.setUp(soc, port, input = False)
  213.                         self.messages.append(mw)
  214.                     
  215.                 soc.hasOutput() is True
  216.             
  217.             self.bindings.append(desc)
  218.         
  219.  
  220.     
  221.     def write(self, fd, msg_fd = None):
  222.         print >>fd, self.imports
  223.         print >>fd, self.locator
  224.         for m in self.bindings:
  225.             print >>fd, m
  226.         
  227.         for m in self.messages:
  228.             print >>fd, m
  229.         
  230.  
  231.  
  232.  
  233. class MessageWriter:
  234.     logger = _GetLogger('MessageWriter')
  235.     
  236.     def __init__(self, do_extended = False):
  237.         self.content = None
  238.         self.do_extended = do_extended
  239.  
  240.     
  241.     def __str__(self):
  242.         if not self.content:
  243.             raise Wsdl2PythonError, 'Must call setUp.'
  244.         
  245.         return self.content.getvalue()
  246.  
  247.     
  248.     def setUp(self, soc, port, input = False):
  249.         rpc = soc.isRPC()
  250.         literal = soc.isLiteral(input)
  251.         kw = { }
  252.         klass = None
  253.         if rpc and literal:
  254.             klass = ServiceRPCLiteralMessageContainer
  255.         elif not rpc and literal:
  256.             kw['do_extended'] = self.do_extended
  257.             klass = ServiceDocumentLiteralMessageContainer
  258.         elif rpc and not literal:
  259.             klass = ServiceRPCEncodedMessageContainer
  260.         else:
  261.             raise WsdlGeneratorError, 'doc/enc not supported.'
  262.         self.content = klass(**kw)
  263.         self.content.setUp(port, soc, input)
  264.  
  265.  
  266.  
  267. class SchemaDescription:
  268.     logger = _GetLogger('SchemaDescription')
  269.     
  270.     def __init__(self, do_extended = False, extPyClasses = None):
  271.         self.classHead = NamespaceClassHeaderContainer()
  272.         self.classFoot = NamespaceClassFooterContainer()
  273.         self.items = []
  274.         self._SchemaDescription__types = []
  275.         self._SchemaDescription__elements = []
  276.         self.targetNamespace = None
  277.         self.do_extended = do_extended
  278.         self.extPyClasses = extPyClasses
  279.  
  280.     
  281.     def fromSchema(self, schema):
  282.         ns = schema.getTargetNamespace()
  283.         if self.targetNamespace is None:
  284.             self.targetNamespace = ns
  285.         
  286.         self.classHead.ns = self.classFoot.ns = ns
  287.         for t in schema.types:
  288.             if t.getAttributeName() not in self._SchemaDescription__types:
  289.                 continue
  290.             _[1][t]
  291.         
  292.         for e in schema.elements:
  293.             if e.getAttributeName() not in self._SchemaDescription__elements:
  294.                 continue
  295.             _[2][e]
  296.         
  297.  
  298.     
  299.     def getTypes(self):
  300.         return self._SchemaDescription__types
  301.  
  302.     
  303.     def getElements(self):
  304.         return self._SchemaDescription__elements
  305.  
  306.     
  307.     def write(self, fd):
  308.         print >>fd, self.classHead
  309.         for t in self.items:
  310.             print >>fd, t
  311.         
  312.         print >>fd, self.classFoot
  313.  
  314.  
  315.  
  316. class SchemaItemWriter:
  317.     logger = _GetLogger('SchemaItemWriter')
  318.     
  319.     def __init__(self, do_extended = False, extPyClasses = None):
  320.         self.content = None
  321.         self.do_extended = do_extended
  322.         self.extPyClasses = extPyClasses
  323.  
  324.     
  325.     def __str__(self):
  326.         return str(self.content)
  327.  
  328.     
  329.     def fromSchemaItem(self, item):
  330.         raise NotImplementedError, ''
  331.  
  332.  
  333.  
  334. class ElementWriter(SchemaItemWriter):
  335.     logger = _GetLogger('ElementWriter')
  336.     
  337.     def fromSchemaItem(self, item):
  338.         if item.isElement() is False or item.isLocal() is True:
  339.             raise TypeError, 'expecting global element declaration: %s' % item.getItemTrace()
  340.         
  341.         local = False
  342.         qName = item.getAttribute('type')
  343.         if not qName:
  344.             etp = item.content
  345.             local = True
  346.         else:
  347.             etp = item.getTypeDefinition('type')
  348.         if etp is None:
  349.             if local is True:
  350.                 self.content = ElementLocalComplexTypeContainer(do_extended = self.do_extended)
  351.             else:
  352.                 self.content = ElementSimpleTypeContainer()
  353.         elif etp.isLocal() is False:
  354.             self.content = ElementGlobalDefContainer()
  355.         elif etp.isSimple() is True:
  356.             self.content = ElementLocalSimpleTypeContainer()
  357.         elif etp.isComplex():
  358.             self.content = ElementLocalComplexTypeContainer(do_extended = self.do_extended)
  359.         else:
  360.             raise Wsdl2PythonError, 'Unknown element declaration: %s' % item.getItemTrace()
  361.         self.logger.debug('ElementWriter setUp container "%r", Schema Item "%s"' % (self.content, item.getItemTrace()))
  362.         self.content.setUp(item)
  363.  
  364.  
  365.  
  366. class TypeWriter(SchemaItemWriter):
  367.     logger = _GetLogger('TypeWriter')
  368.     
  369.     def fromSchemaItem(self, item):
  370.         if item.isDefinition() is False or item.isLocal() is True:
  371.             raise TypeError, 'expecting global type definition not: %s' % item.getItemTrace()
  372.         
  373.         self.content = None
  374.         if item.isSimple():
  375.             if item.content.isRestriction():
  376.                 self.content = RestrictionContainer()
  377.             elif item.content.isUnion():
  378.                 self.content = UnionContainer()
  379.             elif item.content.isList():
  380.                 self.content = ListContainer()
  381.             else:
  382.                 raise Wsdl2PythonError, 'unknown simple type definition: %s' % item.getItemTrace()
  383.             self.content.setUp(item)
  384.             return None
  385.         
  386.         if item.isComplex():
  387.             kw = { }
  388.             if item.content is None or item.content.isModelGroup():
  389.                 self.content = ComplexTypeContainer(do_extended = self.do_extended, extPyClasses = self.extPyClasses)
  390.                 kw['empty'] = item.content is None
  391.             elif item.content.isSimple():
  392.                 self.content = ComplexTypeSimpleContentContainer()
  393.             elif item.content.isComplex():
  394.                 self.content = ComplexTypeComplexContentContainer(do_extended = self.do_extended)
  395.             else:
  396.                 raise Wsdl2PythonError, 'unknown complex type definition: %s' % item.getItemTrace()
  397.             self.logger.debug('TypeWriter setUp container "%r", Schema Item "%s"' % (self.content, item.getItemTrace()))
  398.             
  399.             try:
  400.                 self.content.setUp(item, **kw)
  401.             except Exception:
  402.                 ex = None
  403.                 args = [
  404.                     'Failure in setUp: %s' % item.getItemTrace()]
  405.                 args += ex.args
  406.                 ex.args = tuple(args)
  407.                 raise 
  408.  
  409.             return None
  410.         
  411.         raise TypeError, 'expecting SimpleType or ComplexType: %s' % item.getItemTrace()
  412.  
  413.  
  414.